package test2;

import java.util.*;

/**
 * @author spf
 * @date 2024/9/5
 * @time 20:30
 */
public class Main {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 返回一个整数，表示答案
     * @param a int整型ArrayList<ArrayList<>>
     * @param val int整型
     * @return int整型
     */
//    public List<Integer> removeTwos(List<Integer> arr) {
//        List<Integer> result = new ArrayList<>();
//
//        for (Integer num : arr) {
//            String numStr = num.toString();
//            StringBuilder sb = new StringBuilder();
//
//            // 删除数字 2
//            for (char c : numStr.toCharArray()) {
//                if (c != '2') {
//                    sb.append(c);
//                }
//            }
//
//            // 检查剩余部分是否为空
//            if (sb.length() > 0) {
//                // 转换回整数并添加到结果列表
//                result.add(Integer.parseInt(sb.toString()));
//            }
//        }
//
//        return result;
//    }

//    public ListNode mergeCommonPrefixSuffix(ListNode a, ListNode b) {
//        // 找到公共前缀
//        ListNode commonPrefixEnd = findCommonPrefix(a, b);
//
//        // 找到公共后缀
//        ListNode commonSuffixStart = findCommonSuffix(commonPrefixEnd, b);
//
//        // 拼接公共前缀和后缀
//        ListNode result = merge(commonPrefixEnd, commonSuffixStart);
//
//        return result;
//    }
//
//    private ListNode findCommonPrefix(ListNode a, ListNode b) {
//        while (a != null && b != null && a.val == b.val) {
//            a = a.next;
//            b = b.next;
//        }
//        return a;
//    }
//
//    private ListNode findCommonSuffix(ListNode a, ListNode b) {
//        while (a != null && b != null && a.val == b.val) {
//            a = a.next;
//            b = b.next;
//        }
//        return b;
//    }
//
//    private ListNode merge(ListNode prefixEnd, ListNode suffixStart) {
//        ListNode dummy = new ListNode(-1);
//        ListNode tail = dummy;
//
//        // 拼接公共前缀
//        ListNode current = prefixEnd;
//        while (current != null) {
//            tail.next = current;
//            tail = tail.next;
//            current = current.next;
//        }
//
//        // 拼接公共后缀
//        current = suffixStart;
//        while (current != null) {
//            tail.next = current;
//            tail = tail.next;
//            current = current.next;
//        }
//
//        tail.next = null;
//
//        return dummy.next;
//    }


//    public int countSubmatricesWithMinValueAtLeastK(String[] matrix, int myval) {
//        int n = matrix.length;
//        int count = 0;
//
//        for (int size = 1; size <= n; size++) {
//            for (int i = 0; i + size <= n; i++) {
//                for (int j = 0; j + size <= n; j++) {
//                    int rCount = 0, eCount = 0, dCount = 0;
//                    for (int row = i; row < i + size; row++) {
//                        for (int col = j; col < j + size; col++) {
//                            char ch = matrix[row].charAt(col);
//                            switch (ch) {
//                                case 'r':
//                                    rCount++;
//                                    break;
//                                case 'e':
//                                    eCount++;
//                                    break;
//                                case 'd':
//                                    dCount++;
//                                    break;
//                            }
//                        }
//                    }
//                    int minValue = Math.min(rCount, Math.min(eCount, dCount));
//                    if (minValue >= myval) {
//                        count++;
//                    }
//                }
//            }
//        }
//
//        return count;
//    }

//    public static void main(String[] args) {
////        List<Integer> arr = new ArrayList<>();
////        arr.add(5);
////        arr.add(12);
////        arr.add(20);
////        arr.add(2);
////        arr.add(77);
////        arr.add(12212);
////        arr.add(58);
////        arr.add(2001);
//
//        ListNode arr = new ListNode(1);
//        arr.next = new ListNode(2);
//        arr.next.next = new ListNode(2);
//        arr.next.next.next = new ListNode(3);
//        arr.next.next.next.next = new ListNode(4);
//        ListNode arr1 = new ListNode(1);
//        arr1.next = new ListNode(2);
//        arr1.next.next = new ListNode(1);
//        arr1.next.next.next = new ListNode(2);
//        arr1.next.next.next.next = new ListNode(3);
//        arr1.next.next.next.next.next = new ListNode(3);
//        arr1.next.next.next.next.next.next = new ListNode(4);
//        System.out.println(new Main().countSubmatricesWithMinValueAtLeastK(new String[]{"red", "edr", "dre"}, 1));
//    }



//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        int testCases = scanner.nextInt(); // 读取数据组数
//        scanner.nextLine(); // 消耗换行符
//
//        for (int i = 0; i < testCases; i++) {
//            String bookId = scanner.nextLine();
//            System.out.println(classifyBook(bookId));
//        }
//        scanner.close();
//    }
//
//    private static String classifyBook(String bookId) {
//        // 分类逻辑
//        if (bookId.startsWith("A") && bookId.length() == 5 && Character.isDigit(bookId.charAt(4))) {
//            return "Literature";
//        } else if (bookId.startsWith("B") && bookId.length() == 6 && Character.isDigit(bookId.charAt(1))) {
//            return "Science";
//        } else if (Character.isDigit(bookId.charAt(0)) && bookId.length() == 4 && !Character.isDigit(bookId.charAt(2))) {
//            return "History";
//        } else if (bookId.startsWith("C") && bookId.length() == 7 && countDigits(bookId) >= 2) {
//            return "Art";
//        } else if (bookId.startsWith("D") && bookId.length() == 8 && bookId.substring(0, 4).matches("[A-Z]+") && bookId.substring(4).matches("\\d+")) {
//            return "Technology";
//        } else {
//            return "Uncategorized";
//        }
//    }
//
//    private static int countDigits(String str) {
//        // 计算字符串中数字的数量
//        return (int) str.chars().filter(Character::isDigit).count();
//    }


//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//
//        // 读取数组长度
//        int n = scanner.nextInt();
//
//        // 读取数组元素
//        int[] arr = new int[n];
//        for (int i = 0; i < n; i++) {
//            arr[i] = scanner.nextInt();
//        }
//
//        // 计算最小代价
//        int minCost = calculateMinCost(arr);
//
//        // 输出结果
//        System.out.println(minCost);
//
//        scanner.close();
//    }
//
//    private static int calculateMinCost(int[] arr) {
//        int evenCost = 0; // 将数组变为全偶数的代价
//        int oddCost = 0;  // 将数组变为全奇数的代价
//
//        // 遍历数组，计算两种情况下的代价
//        for (int num : arr) {
//            if (num % 2 == 0) {
//                // 如果当前数是偶数，将其变为奇数的代价为 num + 1
//                oddCost += num + 1;
//            } else {
//                // 如果当前数是奇数，将其变为偶数的代价为 num
//                evenCost += num;
//            }
//        }
//
//        // 返回两种情况中的最小代价
//        return Math.min(evenCost, oddCost);
//    }

//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//
//        // 读取测试数据组数
//        int T = scanner.nextInt();
//
//        for (int t = 0; t < T; t++) {
//            // 读取节点数量
//            int n = scanner.nextInt();
//
//            // 构建邻接表
//            List<List<Integer>> adjList = new ArrayList<>();
//            for (int i = 0; i <= n; i++) {
//                adjList.add(new ArrayList<>());
//            }
//
//            // 读取边信息
//            for (int i = 1; i < n; i++) {
//                int u = scanner.nextInt();
//                int v = scanner.nextInt();
//                adjList.get(u).add(v);
//                adjList.get(v).add(u);
//            }
//
//            // 计算每个节点的子节点数量
//            Map<Integer, Integer> subNodeCount = new HashMap<>();
//            dfs(1, -1, adjList, subNodeCount);
//
//            // 计算相似节点的对数
//            int similarPairs = countSimilarPairs(subNodeCount);
//
//            // 输出结果
//            System.out.println(similarPairs);
//        }
//
//        scanner.close();
//    }
//
//    private static void dfs(int node, int parent, List<List<Integer>> adjList, Map<Integer, Integer> subNodeCount) {
//        int count = 0;
//        for (int child : adjList.get(node)) {
//            if (child != parent) {
//                dfs(child, node, adjList, subNodeCount);
//                count += subNodeCount.get(child) + 1;
//            }
//        }
//        subNodeCount.put(node, count);
//    }
//
//    private static int countSimilarPairs(Map<Integer, Integer   > subNodeCount) {
//        Map<Integer, Integer> frequencyMap = new HashMap<>();
//
//        for (int count : subNodeCount.values()) {
//            frequencyMap.put(count, frequencyMap.getOrDefault(count, 0) + 1);
//        }
//
//        int pairs = 0;
//        for (int freq : frequencyMap.values()) {
//            pairs += freq * (freq - 1) / 2;
//        }
//
//        return pairs;
//    }
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);

            // 读取测试数据组数
            int T = scanner.nextInt();

            for (int t = 0; t < T; t++) {
                // 读取节点数量
                int n = scanner.nextInt();

                // 构建邻接表
                List<List<Integer>> adjList = new ArrayList<>();
                for (int i = 0; i <= n; i++) {
                    adjList.add(new ArrayList<>());
                }

                // 读取边信息
                for (int i = 1; i < n; i++) {
                    int u = scanner.nextInt();
                    int v = scanner.nextInt();
                    adjList.get(u).add(v);
                    adjList.get(v).add(u);
                }

                // 计算每个节点的子节点数量
                Map<Integer, Integer> subNodeCount = new HashMap<>();
                dfs(1, -1, adjList, subNodeCount);

                // 计算相似节点的对数
                int similarPairs = countSimilarPairs(subNodeCount);

                // 输出结果
                System.out.println(similarPairs);
            }

            scanner.close();
        }

        private static void dfs(int node, int parent, List<List<Integer>> adjList, Map<Integer, Integer> subNodeCount) {
            int count = 0;
            for (int child : adjList.get(node)) {
                if (child != parent) {
                    dfs(child, node, adjList, subNodeCount);
                    count += subNodeCount.get(child) + 1;
                }
            }
            subNodeCount.put(node, count);
        }

        private static int countSimilarPairs(Map<Integer, Integer> subNodeCount) {
            Map<Integer, Integer> frequencyMap = new HashMap<>();

            for (int count : subNodeCount.values()) {
                frequencyMap.put(count, frequencyMap.getOrDefault(count, 0) + 1);
            }

            int pairs = 0;
            for (int freq : frequencyMap.values()) {
                pairs += freq * (freq - 1) / 2;
            }

            return pairs;
        }

}

//class ListNode {
//    int val;
//    ListNode next;
//
//    ListNode(int x) {
//        val = x;
//        next = null;
//    }
//}
